home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / common / spelling / pyaspell.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  8.9 KB  |  221 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4.  
  5. try:
  6.     import ctypes
  7.     import ctypes.util as ctypes
  8. except ImportError:
  9.     raise ImportError('ctypes library is needed')
  10.  
  11.  
  12. class AspellError(Exception):
  13.     pass
  14.  
  15.  
  16. class AspellConfigError(AspellError):
  17.     pass
  18.  
  19.  
  20. class AspellSpellerError(AspellError):
  21.     pass
  22.  
  23.  
  24. class Aspell(object):
  25.     VERSION = 5
  26.     if VERSION == 5:
  27.         LIBNAME = 'aspell\\bin\\aspell-15'
  28.     elif VERSION == 6:
  29.         LIBNAME = 'aspell\\bin\\aspell'
  30.     
  31.     
  32.     def __init__(self, configkeys = None, libname = None, **kwds):
  33.         if libname is None:
  34.             libname = ctypes.util.find_library(self.LIBNAME)
  35.         
  36.         self._Aspell__lib = ctypes.CDLL(libname)
  37.         self.libname = libname
  38.         config = self._Aspell__lib.new_aspell_config()
  39.         if config == None:
  40.             raise AspellError("Can't create aspell config object")
  41.         
  42.         if configkeys:
  43.             if hasattr(configkeys, 'items'):
  44.                 configkeys = configkeys.items()
  45.             
  46.             if len(configkeys) == 2 and type(configkeys[0]) is str and type(configkeys[1]) is str:
  47.                 configkeys = [
  48.                     configkeys]
  49.             
  50.             configkeys = dict(configkeys)
  51.         else:
  52.             configkeys = { }
  53.         configkeys.update(kwds)
  54.         configkeys = configkeys.items()
  55.         for key, value in configkeys:
  56.             if not self._Aspell__lib.aspell_config_replace(config, key, value):
  57.                 raise self._aspell_config_error(config)
  58.                 continue
  59.         
  60.         possible_error = self._Aspell__lib.new_aspell_speller(config)
  61.         self._Aspell__lib.delete_aspell_config(config)
  62.         errno = self._Aspell__lib.aspell_error_number(possible_error)
  63.         if errno != 0:
  64.             errmsg = ctypes.string_at(self._Aspell__lib.aspell_error_message(possible_error))
  65.             self._Aspell__lib.delete_aspell_can_have_error(possible_error)
  66.             raise AspellError(errno, errmsg)
  67.         
  68.         self._Aspell__speller = self._Aspell__lib.to_aspell_speller(possible_error)
  69.  
  70.     
  71.     def check(self, word):
  72.         if type(word) is str:
  73.             return bool(self._Aspell__lib.aspell_speller_check(self._Aspell__speller, word, len(word)))
  74.         else:
  75.             raise TypeError('String expeced')
  76.  
  77.     
  78.     def suggest(self, word):
  79.         if type(word) is str:
  80.             return self._aspellwordlist(self._Aspell__lib.aspell_speller_suggest(self._Aspell__speller, word, len(word)))
  81.         else:
  82.             raise TypeError('String expeced')
  83.  
  84.     
  85.     def personal_dict(self, word = None):
  86.         if word is not None:
  87.             self._Aspell__lib.aspell_speller_add_to_personal(self._Aspell__speller, word, len(word))
  88.             self._aspell_check_error()
  89.         else:
  90.             return self._aspellwordlist(self._Aspell__lib.aspell_speller_personal_word_list(self._Aspell__speller))
  91.  
  92.     
  93.     def session_dict(self, word = None, clear = False):
  94.         if clear:
  95.             self._Aspell__lib.aspell_speller_clear_session(self._Aspell__speller)
  96.             self._aspell_check_error()
  97.             return None
  98.         
  99.         if word is not None:
  100.             self._Aspell__lib.aspell_speller_add_to_session(self._Aspell__speller, word, len(word))
  101.             self._aspell_check_error()
  102.         else:
  103.             return self._aspellwordlist(self._Aspell__lib.aspell_speller_session_word_list(self._Aspell__speller))
  104.  
  105.     
  106.     def add_replacement_pair(self, misspelled, correct):
  107.         self._Aspell__lib.aspell_speller_store_replacement(self._Aspell__speller, misspelled, len(misspelled), correct, len(correct))
  108.         self._aspell_check_error()
  109.  
  110.     
  111.     def save_all(self):
  112.         self._Aspell__lib.aspell_speller_save_all_word_lists(self._Aspell__speller)
  113.         self._aspell_check_error()
  114.  
  115.     
  116.     def configkeys(self):
  117.         config = self._Aspell__lib.aspell_speller_config(self._Aspell__speller)
  118.         if config is None:
  119.             raise AspellConfigError("Can't get speller's config")
  120.         
  121.         keys_enum = self._Aspell__lib.aspell_config_possible_elements(config, 1)
  122.         if keys_enum is None:
  123.             raise AspellError("Can't get list of config keys")
  124.         
  125.         
  126.         class KeyInfo(ctypes.Structure):
  127.             _fields_ = [
  128.                 ('name', ctypes.c_char_p),
  129.                 ('type', ctypes.c_int),
  130.                 ('default', ctypes.c_char_p),
  131.                 ('desc', ctypes.c_char_p),
  132.                 ('flags', ctypes.c_int),
  133.                 ('other_data', ctypes.c_int)]
  134.  
  135.         key_next = self._Aspell__lib.aspell_key_info_enumeration_next
  136.         key_next.restype = ctypes.POINTER(KeyInfo)
  137.         list = []
  138.         while True:
  139.             key_info = key_next(keys_enum)
  140.             if not key_info:
  141.                 break
  142.             else:
  143.                 key_info = key_info.contents
  144.             if key_info.type == 0:
  145.                 list.append((key_info.name, key_info.default, key_info.desc))
  146.                 continue
  147.             if key_info.type == 1:
  148.                 list.append((key_info.name, int(key_info.default), key_info.desc))
  149.                 continue
  150.             if key_info.type == 2:
  151.                 if key_info.default.lower() == 'true':
  152.                     list.append((key_info.name, True, key_info.desc))
  153.                 else:
  154.                     list.append((key_info.name, False, key_info.desc))
  155.             key_info.default.lower() == 'true'
  156.             if key_info.type == 3:
  157.                 list.append((key_info.name, key_info.default.split(), key_info.desc))
  158.                 continue
  159.         self._Aspell__lib.delete_aspell_key_info_enumeration(keys_enum)
  160.         return list
  161.  
  162.     
  163.     def reset_cache(self):
  164.         return self._reload_lib()
  165.  
  166.     
  167.     def close(self):
  168.         self._Aspell__lib.delete_aspell_speller(self._Aspell__speller)
  169.  
  170.     
  171.     def _reload_lib(self):
  172.         _LoadLibrary = LoadLibrary
  173.         _FreeLibrary = FreeLibrary
  174.         import _ctypes
  175.         if self._Aspell__lib._handle != 0:
  176.             _FreeLibrary(self._Aspell__lib._handle)
  177.             del self._Aspell__lib
  178.             self._Aspell__lib = ctypes.CDLL(self.libname)
  179.         
  180.  
  181.     
  182.     def _aspellwordlist(self, wordlist_id):
  183.         elements = self._Aspell__lib.aspell_word_list_elements(wordlist_id)
  184.         list = []
  185.         while True:
  186.             wordptr = self._Aspell__lib.aspell_string_enumeration_next(elements)
  187.             if not wordptr:
  188.                 break
  189.                 continue
  190.             word = ctypes.c_char_p(wordptr)
  191.             list.append(word.value)
  192.         self._Aspell__lib.delete_aspell_string_enumeration(elements)
  193.         return list
  194.  
  195.     
  196.     def _aspell_config_error(self, config):
  197.         exc = AspellConfigError(ctypes.c_char_p(self._Aspell__lib.aspell_config_error_message(config)).value)
  198.         self._Aspell__lib.delete_aspell_config(config)
  199.         raise exc
  200.  
  201.     
  202.     def _aspell_check_error(self):
  203.         if self._Aspell__lib.aspell_speller_error(self._Aspell__speller) != 0:
  204.             msg = self._Aspell__lib.aspell_speller_error_message(self._Aspell__speller)
  205.             raise AspellSpellerError(ctypes.string_at(msg))
  206.         
  207.  
  208.  
  209. _test_basic = '>>> a = Aspell((\'lang\', \'en\'))\n>>> a.check("when")\nTrue\n>>> set(a.suggest("wehn")) == set([\'when\', \'wen\', \'wean\', \'ween\', \'Wehr\', \'whens\', \'hen\'])\nTrue\n>>> a.add_replacement_pair("wehn", "ween")\n>>> set(a.suggest("wehn")) == set([\'ween\', \'when\', \'wen\', \'wean\', \'Wehr\', \'whens\', \'hen\'])\nTrue\n>>> a.session_dict() == []\nTrue\n>>> a.check("pyaspell")\nFalse\n>>> a.session_dict("pyaspell")\n>>> a.session_dict() == [\'pyaspell\']\nTrue\n>>> a.check("pyaspell")\nTrue\n>>> a.session_dict(clear=True)\n>>> a.session_dict()\n[]\n>>> a.close()'
  210. _test_locales = ">>> # Locales\n>>> a1 = Aspell(('lang', 'en-us'))\n>>> a2 = Aspell(('lang', 'en-gb'))\n>>> (a1.check('localize'), a2.check('localize')) == (True, False)\nTrue\n>>> (a1.check('localize'), a2.check('localize')) == (True, False)\nTrue\n>>> (a1.check('localise'), a2.check('localise')) == (False, True)\nTrue\n>>> (a1.suggest('localise')[0], a2.suggest('localize')[0]) == ('localize', 'localise')\nTrue\n>>> a1.close()\n>>> a2.close()"
  211. _test_case = ">>> # Case sensitivity\n>>> a1 = Aspell(('ignore-case',''))\n>>> a2 = Aspell(('dont-ignore-case', ''))\n>>> (a1.check('steve'), a2.check('steve')) == (True, False)\nTrue\n>>> (a1.check('Steve'), a2.check('Steve')) == (True, True)\nTrue\n>>> a1.close()\n>>> a2.close()"
  212. __test__ = dict(basic = _test_basic, locales = _test_locales, case = _test_case)
  213.  
  214. def _test():
  215.     import doctest
  216.     doctest.testmod(verbose = True)
  217.  
  218. if __name__ == '__main__':
  219.     Aspell(('lang', 'fake'))
  220.  
  221.